
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.brain.sele.view.mbean;

import com.brain.core.common.UtilCore;
import com.brain.core.configuracion.WebServletContextListener;
import com.brain.core.view.mbean.*;
import com.brain.core.dto.ParametroDto;
import com.brain.core.exception.DAOException;
import com.brain.core.manager.RecursosManager;
import com.brain.core.view.util.ConstantesCore;
import com.brain.sele.dto.ConvocMedioDifusionDto;
import com.brain.sele.dto.ConvocatoriaDto;
import com.brain.sele.dto.ConvocatoriaEvaluacionDto;
import com.brain.sele.dto.MiembroComiteDto;
import com.brain.sele.dto.PostulanteDto;
import com.brain.sele.dto.RequerimientoDto;
import com.brain.sele.dto.ResponsableDto;
import com.brain.sele.manager.CalificacionManager;
import com.brain.sele.manager.ConvocatoriaManager;
import com.brain.sele.manager.ConvocatoriaMedioDifusionManager;
import com.brain.sele.manager.MiembroComiteManager;
import com.brain.sele.manager.PostulanteManager;
import com.brain.sele.manager.RequerimientoManager;
import com.brain.sele.manager.ResponsableManager;
import com.brain.sele.view.util.ConstantesSele;
import com.brain.sgc.dto.MedioDifusionDto;
import com.brain.sgc.dto.PersonaDto;
import com.brain.sgc.dto.ProcesoEvaluacionDto;
import com.brain.sgc.dto.ProcesoSGCDto;
import com.brain.sgc.manager.ProcesoEvaluacionManager;
import com.brain.sgc.manager.ProcesoSGCManager;
import com.brain.sgc.view.mbean.LegajoMBean;
import com.brain.sgc.view.mbean.PersonaMBean;
import com.brain.sgc.view.util.ConstantesSgc;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

import javax.annotation.Resource;
import javax.faces.event.ActionEvent;
import net.sf.jasperreports.engine.JRException;
import org.apache.log4j.Logger;
import org.primefaces.context.RequestContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

/**
 *
 * @author Hvives
 */
@Controller("convocatoriaMBean")
@Scope("session")
public class ConvocatoriaMBean extends GenericMBean implements Serializable {

    private static Logger logger = Logger.getLogger(ConvocatoriaMBean.class);
    @Resource
    private ConvocatoriaManager manager;
    @Resource
    private RecursosManager recursosManager;
    @Resource
    private RequerimientoManager requerimientoManager;
    @Resource
    private PostulanteManager postulanteManager;
    @Resource
    private ResponsableManager responsableManager;
    @Resource
    private CalificacionManager calificacionManager;
    @Resource
    private ConvocatoriaMedioDifusionManager convMedioDifuManager;
    @Resource
    private MiembroComiteManager miemComiteManager;
    @Resource
    private ProcesoEvaluacionManager procEvaluacionManager;
    private List<ConvocatoriaDto> lista;
    private ConvocatoriaDto dto;
    private ConvocatoriaDto dtoFiltro;
    private String keyTitulo = "convocatoria.panel";
    @Autowired
    private ApplicationMBean applicationMBean;
    @Autowired
    private SessionMBean sessionMBean;
    private List<ParametroDto> listaEstadosConvocatoria;
    private List<ProcesoSGCDto> listaProcesosFiltro;
    private List<ProcesoSGCDto> listaProcesosNuevo;
    private List<ConvocatoriaEvaluacionDto> listaConvocatoriaEvaluacion;
    private List<RequerimientoDto> listaReqAprobados;
    private List<RequerimientoDto> listaRequerimientosPorConvocatoria;
    private RequerimientoDto[] selectedReqs;
    private PersonaDto[] selectedPostulantes;
    private RequerimientoDto requerimientoDto;
    private MedioDifusionDto medioDifusionDto;
    private ConvocMedioDifusionDto convMedioDifusionDto;
    private MiembroComiteDto miembroComiteSelectDto;
    private MiembroComiteDto miembroComiteDto;
    private PostulanteDto postulanteDto;
    private List<ResponsableDto> listaResponsablesPorReq;
    private List<PostulanteDto> listaPostulantesDto;
    private List<PostulanteDto> listaPostulantesPorConvDto;
    private List<ParametroDto> listaTiposMiemComite;
    private Boolean accesoBtnPublicar;
    private Boolean accesoBtnAnular;
    private Boolean accesoBtnCerrar;
    private Boolean accesoBtnGuardar;
    private Boolean accesoBtnTerminar;
    private Boolean accesoBtnVerPost;
    private Date fechaActual;
    private ConvocatoriaEvaluacionDto convEvaluacionDto;

    public ConvocatoriaMBean() {
        this.dtoFiltro = new ConvocatoriaDto();
    }

    public String iniciar() {
        this.dto = null;
        this.lista = null;
        this.dtoFiltro = new ConvocatoriaDto();
        this.dtoFiltro.setProcesoDto(new ProcesoSGCDto());
        return ConstantesSele.UrlNavegacion.URL_LISTA_CONVOCATORIA;
    }

    public String nuevo() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.NUEVO);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.lista = new ArrayList<ConvocatoriaDto>();
        this.dto = manager.inicializar();
        this.gestionAcceso();
        this.cargarProcesoPorDefecto();
        return ConstantesSele.UrlNavegacion.URL_CONVOCATORIA;
    }

    protected void cargarProcesoPorDefecto() {
        try {
            ProcesoSGCManager procesoSGCManager = (ProcesoSGCManager) WebServletContextListener.getApplicationContext().getBean("procesoSGCManager");
            List<ProcesoSGCDto> listProc = procesoSGCManager.obtenerProcesosActivos();
            if (!listProc.isEmpty()) {
                this.evaluacionPorProceso(listProc.get(0).getId());
                this.dto.setProcesoDto(new ProcesoSGCDto(listProc.get(0).getId()));
            } else {
                this.accesoBtnGuardar = false;
                showError(UtilCore.Internacionalizacion.getMensajeInternacional("convocatoria.mensaje.no.procesos"));
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public String editar() {
        try {
            sessionMBean.setAccion(ConstantesSgc.Formulario.EDITAR);
            sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
            //Obtenemos el dto desde base de datos para evitar tener datos en memoria
            this.dto = this.manager.obtenerConvocatoriaPorId(this.dto.getId());
            this.cargarConvEvaluacion();
            this.miembroComiteSelectDto = new MiembroComiteDto();
            this.gestionAcceso();
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return ConstantesSele.UrlNavegacion.URL_CONVOCATORIA;
    }

    public String ver() {
        sessionMBean.setAccion(ConstantesSgc.Formulario.VER);
        sessionMBean.setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean.getAccion()));
        this.gestionAcceso();
        return ConstantesSele.UrlNavegacion.URL_CONVOCATORIA;
    }

    public void gestionAcceso() {
        this.accesoBtnPublicar = false;
        this.accesoBtnAnular = false;
        this.accesoBtnCerrar = false;
        this.accesoBtnTerminar = false;
        this.accesoBtnGuardar = true;
        this.accesoBtnVerPost = false;
        try {
            if (dto.getId() != null) {
                if (this.dto.getEstadoDto().getValorEntero() == 1L) {//Elaboracion
                    this.accesoBtnPublicar = true;
                    this.accesoBtnAnular = true;
                    this.accesoBtnGuardar = true;
                } else if (this.dto.getEstadoDto().getValorEntero() == 2L) {//Publicada
                    this.accesoBtnCerrar = true;
                    this.accesoBtnTerminar = true;
                    this.accesoBtnGuardar = false;
                } else if (this.dto.getEstadoDto().getValorEntero() == 3L) {//Cerrada
                    this.accesoBtnGuardar = false;
                    this.accesoBtnTerminar = true;
                } else if (this.dto.getEstadoDto().getValorEntero() == 4L) {//Anulada
                    this.accesoBtnGuardar = false;
                } else if (this.dto.getEstadoDto().getValorEntero() == 5L) {//Terminada
                    this.accesoBtnGuardar = false;
                }
                //Si la accion es = VER
                if (sessionMBean.getAccion() == 3) {
                    this.accesoBtnGuardar = false;
                }
                if (this.postulanteManager.obtenerCantPostulantesPorConv(this.dto.getId()) > 0) {
                    this.accesoBtnVerPost = true;
                }
            }
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void buscar(ActionEvent ae) {

        try {
            this.lista = this.manager.obtenerConvocatorias(this.dtoFiltro);
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            //showError(ex.getMessage());
        }

    }

    public String guardar() {
        try {
            ConvocatoriaDto dtoConvAux = this.dto;
            this.dto = this.manager.guardar(this.dto, this.listaConvocatoriaEvaluacion);
            if (this.dto != null) {
                this.dto = this.manager.obtenerConvocatoriaPorId(this.dto.getId());
                return this.editar();
            } else {
                this.dto = dtoConvAux;
            }

        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public String publicar() {
        ConvocatoriaDto responseDto = this.manager.publicar(this.dto);
        if (responseDto != null) {
            this.dtoFiltro.setId(responseDto.getId());
            return retroceder();
        }
        return "";
    }

    public String anular() {
        ConvocatoriaDto responseDto = this.manager.anular(this.dto);
        if (responseDto != null) {
            this.dtoFiltro.setId(responseDto.getId());
            return retroceder();
        }
        return "";
    }

    public String cerrar() {
        ConvocatoriaDto responseDto = this.manager.cerrar(this.dto);
        if (responseDto != null) {
            this.dtoFiltro.setId(responseDto.getId());
            return retroceder();
        }
        return "";
    }

    public String terminar() {
        ConvocatoriaDto responseDto = this.manager.terminar(this.dto);
        if (responseDto != null) {
            this.dtoFiltro.setId(responseDto.getId());
            return retroceder();
        }
        return "";
    }

    public String retroceder() {
        buscar(null);
        sessionMBean.setAccion(ConstantesSgc.Formulario.LISTA);
        sessionMBean().setTitulo(recursosManager.construirTitulo(keyTitulo, sessionMBean().getAccion()));
        return ConstantesSele.UrlNavegacion.URL_LISTA_CONVOCATORIA;
    }

    public void verPostulantes() {
        try {
            this.listaPostulantesPorConvDto = postulanteManager.obtenerPostulantesPorConv(this.dto.getId());
        } catch (DAOException ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public String verSeguimiento() {
        SeguimientoConvocatoriaMBean seguimientoMBean = (SeguimientoConvocatoriaMBean) WebServletContextListener.getApplicationContext().getBean("seguimientoConvocatoriaMBean");
        seguimientoMBean.iniciar();
        seguimientoMBean.setUrlInvocador(ConstantesSele.UrlNavegacion.URL_LISTA_CONVOCATORIA);
        seguimientoMBean.setDto(this.dto);
        return seguimientoMBean.verRequerimientosAux();
    }

// INICIO METODOS EVALUACION PROCESO
    protected void obtenerEvaluacionProceso(Long id) {
        try {
            this.listaConvocatoriaEvaluacion = new ArrayList<ConvocatoriaEvaluacionDto>();
            ConvocatoriaEvaluacionDto dtoConvEvaluacion;
            List<ProcesoEvaluacionDto> l = this.procEvaluacionManager.obtenerProcesosPorEvaluacionActivos(id);
            if (!l.isEmpty()) {
                this.accesoBtnGuardar = true;
                Date fechaAux = UtilCore.Fecha.obtenerFechaActualDate();
                for (ProcesoEvaluacionDto x : l) {
                    dtoConvEvaluacion = new ConvocatoriaEvaluacionDto();
                    dtoConvEvaluacion.setFechaInicio(fechaAux);
                    fechaAux = UtilCore.Fecha.agregarDiasFechaDate(dtoConvEvaluacion.getFechaInicio(), 2);
                    dtoConvEvaluacion.setFechaFin(fechaAux);
                    dtoConvEvaluacion.setEvaluacionDto(x.getEvaluacionDto());
                    dtoConvEvaluacion.setNotaMinimaAprob(x.getEvaluacionDto().getNotaMinimaAprob());
                    dtoConvEvaluacion.setPorcentaje(x.getPorcentaje());
                    dtoConvEvaluacion.setOrden(x.getOrden());
                    dtoConvEvaluacion.setNotaMaxima(x.getEvaluacionDto().getNotaMaxima());
                    dtoConvEvaluacion.setEstado(Boolean.TRUE);
                    listaConvocatoriaEvaluacion.add(dtoConvEvaluacion);
                }
            } else {
                this.accesoBtnGuardar = false;
                showError(UtilCore.Internacionalizacion.getMensajeInternacional("convocatoria.mensaje.no.evaluaciones.proceso"));
            }

        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void evaluacionPorProceso(Long id) {
        this.obtenerEvaluacionProceso(id);
    }

    public void evaluacionPorProceso() {
        this.obtenerEvaluacionProceso(this.dto.getProcesoDto().getId());
    }
// FIN METODOS EVALUACION PROCESO

// INICIO METODOS RESPONSABLE POR ETAPA
    public String cargarPopupRespPorEtapa() {
        try {
            this.listaResponsablesPorReq = this.responsableManager.obtenerResponsablesPorReq(this.requerimientoDto.getId());
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public String agregarRespPorEtapa() {
        try {
            for (ResponsableDto x : this.listaResponsablesPorReq) {
                x.setUsuarioCreacion(sessionMBean.getSessionUsuarioDto().getId());
                x.setFechaCreacion(UtilCore.Fecha.obtenerFechaActualDate());
                x.setTerminalCreacion(sessionMBean.getSessionTerminal());
                x.setEstado(Boolean.TRUE);
                this.responsableManager.editar(x);
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public List<MiembroComiteDto> autoCompletarMiembroComite(String query) {
        List<MiembroComiteDto> results = null;
        try {
            results = this.miemComiteManager.obtenerMiembrosComitePorConvocatoria(this.dto.getId(), query);
        } catch (DAOException ex) {
            logger.error(ex);
            results = new ArrayList<MiembroComiteDto>();
        }
        return results;
    }
// FIN METODOS RESPONSABLE POR ETAPA

// INICIO METODOS CONVOCATORIA EVALUACION
    protected void cargarConvEvaluacion() {
        this.listaConvocatoriaEvaluacion = this.dto.getListaConvocatoriaEvaluacion();
    }

// FIN METODOS CONVOCATORIA EVALUACION
// INICIO METODOS CONVOCATORIA REQUERIMIENTO
    public String eliminarReqConvocatoria() {
        this.accesoBtnVerPost = false;
        try {
            //Eliminamos las calificaciones del requerimiento
            this.calificacionManager.eliminarMuchos(this.calificacionManager.obtenerCalificacionesPorRequerimiento(this.requerimientoDto.getId()));
            //Eliminamos los postulantes asociados a dicho requerimiento
            this.postulanteManager.eliminarMuchos(this.postulanteManager.obtenerPostulantesPorRequerimiento(this.requerimientoDto.getId()));
            //Eliminamos los responsables de la convocatoria
            this.responsableManager.eliminarMuchos(this.responsableManager.obtenerResponsablesPorReq(this.requerimientoDto.getId()));
            //Quitamos la referencia de la convocatoria en el requerimiento
            this.requerimientoDto.setConvocatoriaDto(null);
            this.requerimientoManager.editar(this.requerimientoDto);
            this.recuperarDtoPadre();
            if (this.postulanteManager.obtenerCantPostulantesPorConv(this.dto.getId()) > 0) {
                this.accesoBtnVerPost = true;
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return ConstantesSele.UrlNavegacion.URL_CONVOCATORIA;
    }

    public String cargarPopupRequerimiento() {
        try {
            this.selectedReqs = null;
            this.listaReqAprobados = this.requerimientoManager.obtenerRequerimientosAprobados();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return "";
    }

    public void agregarReqConvocatoria() {
        for (RequerimientoDto x : selectedReqs) {
            try {
                x.setConvocatoriaDto(this.dto);
                //Obtener la etapa actual
                x.setEtapaActualDto(this.obtenerPrimeraEtapa());
                this.requerimientoManager.editar(x);
                this.recuperarDtoPadre();
            } catch (Exception ex) {
                logger.error("ERROR DE SISTEMA", ex);
                showError(ex.getMessage());
            }
        }
    }

    protected ConvocatoriaEvaluacionDto obtenerPrimeraEtapa() {
        ConvocatoriaEvaluacionDto result = null;
        for (ConvocatoriaEvaluacionDto ce : this.dto.getListaConvocatoriaEvaluacion()) {
            if (ce.getOrden() == 1) {
                result = ce;
            }
        }
        return result;
    }

    protected void recuperarDtoPadre() {
        try {
            this.dto = this.manager.obtenerConvocatoriaPorId(this.dto.getId());
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void cargarPopupPostulanteInterno() {
        PersonaMBean personaMBean = (PersonaMBean) WebServletContextListener.getApplicationContext().getBean("personaMBean");
        personaMBean.iniciar();
        //personaMBean.setLista(new ArrayList<PersonaDto>());

    }

    public void cargarPopupPostulanteExterno() {
        PersonaMBean personaMBean = (PersonaMBean) WebServletContextListener.getApplicationContext().getBean("personaMBean");
        personaMBean.iniciar();
        //personaMBean.setLista(new ArrayList<PersonaDto>());
    }

    public void agregarPostConvocatoria() {
        RequestContext context = RequestContext.getCurrentInstance();
        boolean resultado = true;
        this.accesoBtnVerPost = false;
        try {
            List<PostulanteDto> listPost = new ArrayList<PostulanteDto>();
            PostulanteDto dtoPost = null;
            for (PersonaDto person : this.selectedPostulantes) {
                //Verificamos si el postulante esta asignado al requerimiento
                if (this.isUniquePostulante(person)) {
                    dtoPost = new PostulanteDto();
                    dtoPost.setUsuarioCreacion(sessionMBean.getSessionUsuarioDto().getId());
                    dtoPost.setFechaCreacion(UtilCore.Fecha.obtenerFechaActualDate());
                    dtoPost.setTerminalCreacion(sessionMBean.getSessionTerminal());
                    dtoPost.setPersonaDto(person);
                    dtoPost.setRequerimientoDto(this.requerimientoDto);
                    dtoPost.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_EVALUACION));
                    listPost.add(dtoPost);
                } else {
                    resultado = false;
                }
            }
            this.postulanteManager.nuevoMuchos(listPost);
            if (this.postulanteManager.obtenerCantPostulantesPorConv(this.dto.getId()) > 0) {
                this.accesoBtnVerPost = true;
            }
            if (resultado) {
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            } else {
                resultado = true;
                showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("popup.postulante.mensaje.repetidos"));
            }
        } catch (Exception ex) {
            resultado = false;
        }
        context.addCallbackParam("CallbackParam", resultado);
    }

    protected Boolean isUniquePostulante(PersonaDto p) {
        try {
            for (RequerimientoDto r : this.dto.getListaConvocaRequerimiento()) {
                if (this.postulanteManager.verificarPostEnRequerimiento(p.getId(), r.getId()) > 0) {
                    return false;
                }
            }
        } catch (Exception ex) {
            logger.error(ex.getMessage());
        }
        return true;
    }

    public String completarInformacion() {
        LegajoMBean legajoMBean = (LegajoMBean) WebServletContextListener.getApplicationContext().getBean("legajoMBean");
        legajoMBean.setPersonaDto(this.postulanteDto.getPersonaDto());
        legajoMBean.setUrlInvocador(ConstantesSele.UrlNavegacion.URL_LISTA_POSTULANTES_SELECCIONADOS);
        return legajoMBean.iniciar();
    }

// FIN METODOS CONVOCATORIA REQUERIMIENTO    
// INICIO METODOS CONVOCATORIA MEDIOS DIFUSION
    public void agregarConvMedioDifusion() {
        try {
            ConvocMedioDifusionDto convMedioDifuDto = new ConvocMedioDifusionDto();
            convMedioDifuDto.setUsuarioCreacion(sessionMBean.getSessionUsuarioDto().getId());
            convMedioDifuDto.setFechaCreacion(UtilCore.Fecha.obtenerFechaActualDate());
            convMedioDifuDto.setTerminalCreacion(sessionMBean.getSessionTerminal());
            convMedioDifuDto.setConvocatoriaDto(this.dto);
            convMedioDifuDto.setEstado(Boolean.TRUE);
            convMedioDifuDto.setMedioDifusionDto(this.medioDifusionDto);
            this.convMedioDifuManager.nuevo(convMedioDifuDto);
            this.recuperarDtoPadre();

        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.medioDifusionDto = null;
    }

    public void eliminarConvMedioDifusion() {
        try {
            this.convMedioDifuManager.eliminar(this.convMedioDifusionDto);
            this.recuperarDtoPadre();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
// FIN METODOS CONVOCATORIA MEDIOS DIFUSION

// INICIO METODOS MIEMBROS COMITE
    public void agregarMiembroComite() {
        try {
            MiembroComiteDto miemComiteDto = new MiembroComiteDto();
            miemComiteDto.setUsuarioCreacion(sessionMBean.getSessionUsuarioDto().getId());
            miemComiteDto.setFechaCreacion(UtilCore.Fecha.obtenerFechaActualDate());
            miemComiteDto.setTerminalCreacion(sessionMBean.getSessionTerminal());
            miemComiteDto.setConvocatoriaDto(this.dto);
            miemComiteDto.setMiembroDto(this.miembroComiteSelectDto.getMiembroDto());
            miemComiteDto.setTipoDto(this.miembroComiteSelectDto.getTipoDto());
            miemComiteDto.setEstado(Boolean.TRUE);
            this.miemComiteManager.nuevo(miemComiteDto);
            this.recuperarDtoPadre();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
        }
        this.miembroComiteSelectDto = new MiembroComiteDto();
    }

    public void eliminarMiembroComite() {
        Boolean resultado = true;
        try {
            if (this.responsableManager.obtenerCantidadRespPorMiemComite(this.miembroComiteDto) > 0) {
                showWarning(UtilCore.Internacionalizacion.getMensajeInternacional("convocatoria.mensaje.eliminacion.miem_comite"));
            } else {
                this.miemComiteManager.eliminar(this.miembroComiteDto);
                this.recuperarDtoPadre();
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }
// FIN METODOS MIEMBROS COMITE

//INICIO METODOS RESULTADOS
    public String verResultados() {
        this.accesoBtnVerPost = false;
        //Obtener Postulantes APROBADOS Y SELECCIONADOS

//            this.listaPostulantesDto = this.postulanteManager.obtenerPostulantesAprobadosYSeleccionadosPorConv(this.dto.getId());
        try {
            if (this.postulanteManager.obtenerCantPostulantesPorConv(this.dto.getId()) > 0) {
                this.accesoBtnVerPost = true;
            }
            this.obtenerResultados();
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
        return ConstantesSele.UrlNavegacion.URL_LISTA_POSTULANTES_SELECCIONADOS;
    }

    protected void obtenerResultados() {
        try {
            this.listaRequerimientosPorConvocatoria = this.dto.getListaConvocaRequerimiento();
            //Obtenemos los postulantes aprobados y seleccionados por requerimiento
            for (RequerimientoDto r : this.listaRequerimientosPorConvocatoria) {
                r.setListaPostulantes(this.postulanteManager.obtenerPostulantesAprobadosYSeleccionadosPorReq(r.getId()));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void desistirPostulanteYBuscarReemplazo() {
        RequestContext context = RequestContext.getCurrentInstance();
        boolean resultado = true;

        try {
            //Verificamos si existe algun postulante aprobado que pueda sustituir a este
            List<PostulanteDto> listaPostAprob = this.postulanteManager.obtenerPostulantesAprobadosPorReq(this.postulanteDto.getRequerimientoDto().getId());
            if (listaPostAprob.isEmpty()) {
                resultado = false;
            } else {
                //Habilitamos al primer aprobado para que sustituya al postulante desistido
                PostulanteDto postASeleccionar = listaPostAprob.get(0);
                postASeleccionar.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_SELECCIONADO));
                this.postulanteManager.editar(postASeleccionar);
                //Desistimos al otro postulante
                this.postulanteDto.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_DESISTIDO));
                this.postulanteManager.editar(this.postulanteDto);
                //this.listaPostulantesDto = this.postulanteManager.obtenerPostulantesAprobadosYSeleccionadosPorConv(this.dto.getId());
                this.obtenerResultados();
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }

        context.addCallbackParam("CallbackParam", resultado);
    }

    public void desistirPostulanteSinReemplazo() {
        try {
            //Desistimos al otro postulante
            this.postulanteDto.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_DESISTIDO));
            this.postulanteManager.editar(this.postulanteDto);
            this.listaPostulantesDto = this.postulanteManager.obtenerPostulantesAprobadosYSeleccionadosPorConv(this.dto.getId());
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

// FIN METODOS RESULTADOS
//INICIO METODOS ENVIAR A CONTRATAR
    public void enviarAContratar() {
        try {
            this.postulanteDto.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_POR_CONTRATAR));
            this.postulanteManager.editar(postulanteDto);
            //this.listaPostulantesDto = this.postulanteManager.obtenerPostulantesAprobadosYSeleccionadosPorConv(this.dto.getId());
            this.obtenerResultados();
            showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

    public void enviarAContratarTodos() {
        try {
            Boolean indicador = false;
            if (!this.listaRequerimientosPorConvocatoria.isEmpty()) {
                for (RequerimientoDto r : this.listaRequerimientosPorConvocatoria) {
                    if (r.getListaPostulantes() != null && !r.getListaPostulantes().isEmpty()) {
                        for (PostulanteDto p : r.getListaPostulantes()) {
                            indicador = true;
                            p.setEstadoDto(new ParametroDto(ConstantesSele.Parametro.POST_ESTADO_POR_CONTRATAR));
                            this.postulanteManager.editar(p);
                            //this.listaPostulantesDto = this.postulanteManager.obtenerPostulantesAprobadosYSeleccionadosPorConv(this.dto.getId());
                        }
                    }
                }
                if (!indicador) {
                    showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("convocatoria.mensaje_no_post_en_requerimiento"));
                } else {
                    this.obtenerResultados();
                    showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("form.general.mensaje.transaccion.ok"));
                }
            } else {
                showMessage(UtilCore.Internacionalizacion.getMensajeInternacional("convocatoria.mensaje_no_req_resultados"));
            }
        } catch (Exception ex) {
            logger.error("ERROR DE SISTEMA", ex);
            showError(ex.getMessage());
        }
    }

//FIN METODOS ENVIAR A CONTRATAR
    public void iniciarDatosFiltro() {
        this.lista = null;
        this.dtoFiltro = new ConvocatoriaDto();
        this.dtoFiltro.setProcesoDto(new ProcesoSGCDto());
        this.dtoFiltro.setEstadoDto(new ParametroDto());
    }

    public String imprimirDto() {
        try {
            String nombreArchivoReporte = "SGC_CONSOLIDADO_CONVOCARORIA_NRO_" + this.dto.getId();
            HashMap parametros = new HashMap();
            parametros.put("P_IDENTIFICADOR", BigDecimal.valueOf(this.dto.getId()));
            recursosManager.viewReportePdf(parametros, "RptConsolidConvocatoria", nombreArchivoReporte);
            return null;
        } catch (FileNotFoundException ex) {
            showError("EL ARCHIVO NO SE ENCUENTRA");
            logger.error(ex);
        } catch (JRException ex) {
            logger.error(ex);
            showError("ERROR EN LA COMPILACIÓN DEL REPORTE");
        } catch (IOException ex) {
            showError("EL ARCHIVO ESTÁ DAÑADO");
            logger.error(ex);
        } catch (SQLException ex) {
            logger.error(ex);
            showError("ERROR EN LA CONSULTA DEL REPORTE");
        } finally {
            return null;
        }
    }

    public String generarActa() {
        try {
            String nombreArchivoReporte = "SGC_ACTA_CONVOCARORIA_NRO_" + this.dto.getId();
            HashMap parametros = new HashMap();
            parametros.put("P_IDENTIFICADOR", BigDecimal.valueOf(this.dto.getId()));
            parametros.put("P_SIMBOLO", "SIMBOLO.png");
            parametros.put("P_DESC_CONV", this.dto.getDescripcion());
            parametros.put("P_ANIO", String.valueOf(UtilCore.Fecha.obtenerAnioActual()));
            recursosManager.viewReportePdf(parametros, "RptActaConvocatoria", nombreArchivoReporte);
            return null;
        } catch (FileNotFoundException ex) {
            showError("EL ARCHIVO NO SE ENCUENTRA");
            logger.error(ex);
        } catch (JRException ex) {
            logger.error(ex);
            showError("ERROR EN LA COMPILACIÓN DEL REPORTE");
        } catch (IOException ex) {
            showError("EL ARCHIVO ESTÁ DAÑADO");
            logger.error(ex);
        } catch (SQLException ex) {
            logger.error(ex);
            showError("ERROR EN LA CONSULTA DEL REPORTE");
        } finally {
            return null;
        }
    }

    public String imprimirResumenEvaluacion() {
        try {
            String nombreArchivoReporte = "SGC_" + this.dto.getDescripcion() + "_" + this.requerimientoDto.getDescripcion() + "_" + this.convEvaluacionDto.getEvaluacionDto().getDescripcion();
            HashMap parametros = new HashMap();
            parametros.put("P_REQUERIMIENTO", BigDecimal.valueOf(this.requerimientoDto.getId()));
            parametros.put("P_EVALUACION", BigDecimal.valueOf(this.convEvaluacionDto.getId()));
            recursosManager.viewReportePdf(parametros, "RptResumenEtapa", nombreArchivoReporte);
            return null;
        } catch (FileNotFoundException ex) {
            showError("EL ARCHIVO NO SE ENCUENTRA");
            logger.error(ex);
        } catch (JRException ex) {
            logger.error(ex);
            showError("ERROR EN LA COMPILACIÓN DEL REPORTE");
        } catch (IOException ex) {
            showError("EL ARCHIVO ESTÁ DAÑADO");
            logger.error(ex);
        } catch (SQLException ex) {
            logger.error(ex);
            showError("ERROR EN LA CONSULTA DEL REPORTE");
        } finally {
            return null;
        }
    }

    public ConvocatoriaDto getDto() {
        return dto;
    }

    public void setDto(ConvocatoriaDto dto) {
        this.dto = dto;
    }

    public String getKeyTitulo() {
        return keyTitulo;
    }

    public void setKeyTitulo(String keyTitulo) {
        this.keyTitulo = keyTitulo;
    }

    public List<ConvocatoriaDto> getLista() {
        return lista;
    }

    public void setLista(List<ConvocatoriaDto> lista) {
        this.setLista(lista);
    }

    public ConvocatoriaManager getManager() {
        return manager;
    }

    public void setManager(ConvocatoriaManager manager) {
        this.manager = manager;
    }

    public ConvocatoriaDto getDtoFiltro() {
        return dtoFiltro;
    }

    public void setDtoFiltro(ConvocatoriaDto dtoFiltro) {
        this.dtoFiltro = dtoFiltro;
    }

    public List<ParametroDto> getListaEstadosConvocatoria() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistemaAdd(ConstantesSele.CatalogoParametro.CONVOCATORIA_ESTADOS, ConstantesCore.Parametro.TODOS);
    }

    public void setListaEstadosConvocatoria(List<ParametroDto> listaEstadosConvocatoria) {
        this.listaEstadosConvocatoria = listaEstadosConvocatoria;
    }

    public List<ProcesoSGCDto> getListaProcesosFiltro() {
        ProcesoSGCManager procesoSGCManager = (ProcesoSGCManager) WebServletContextListener.getApplicationContext().getBean("procesoSGCManager");
        return procesoSGCManager.obtenerProcesosActivosCombo();
    }

    public void setListaProcesosFiltro(List<ProcesoSGCDto> listaProcesosFiltro) {
        this.listaProcesosFiltro = listaProcesosFiltro;
    }

    public List<ProcesoSGCDto> getListaProcesosNuevo() {
        try {
            ProcesoSGCManager procesoSGCManager = (ProcesoSGCManager) WebServletContextListener.getApplicationContext().getBean("procesoSGCManager");
            return procesoSGCManager.obtenerProcesosActivos();
        } catch (DAOException ex) {
            logger.error(ex);
        }
        return null;
    }

    public void setListaProcesosNuevo(List<ProcesoSGCDto> listaProcesosNuevo) {
        this.listaProcesosNuevo = listaProcesosNuevo;
    }

    public RecursosManager getRecursosManager() {
        return recursosManager;
    }

    public void setRecursosManager(RecursosManager recursosManager) {
        this.recursosManager = recursosManager;
    }

    public ApplicationMBean getApplicationMBean() {
        return applicationMBean;
    }

    public void setApplicationMBean(ApplicationMBean applicationMBean) {
        this.applicationMBean = applicationMBean;
    }

    public SessionMBean getSessionMBean() {
        return sessionMBean;
    }

    public void setSessionMBean(SessionMBean sessionMBean) {
        this.sessionMBean = sessionMBean;
    }

    public List<ConvocatoriaEvaluacionDto> getListaConvocatoriaEvaluacion() {
        UtilCore.General.ordena(listaConvocatoriaEvaluacion, "orden");
        return listaConvocatoriaEvaluacion;
    }

    public void setListaConvocatoriaEvaluacion(List<ConvocatoriaEvaluacionDto> listaConvocatoriaEvaluacion) {
        this.listaConvocatoriaEvaluacion = listaConvocatoriaEvaluacion;
    }

    public List<RequerimientoDto> getListaReqAprobados() {
        return listaReqAprobados;
    }

    public void setListaReqAprobados(List<RequerimientoDto> listaReqAprobados) {
        this.listaReqAprobados = listaReqAprobados;
    }

    public static Logger getLogger() {
        return logger;
    }

    public static void setLogger(Logger logger) {
        ConvocatoriaMBean.logger = logger;
    }

    public RequerimientoDto[] getSelectedReqs() {
        return selectedReqs;
    }

    public void setSelectedReqs(RequerimientoDto[] selectedReqs) {
        this.selectedReqs = selectedReqs;
    }

    public RequerimientoDto getRequerimientoDto() {
        return requerimientoDto;
    }

    public void setRequerimientoDto(RequerimientoDto requerimientoDto) {
        this.requerimientoDto = requerimientoDto;
    }

    public ConvocMedioDifusionDto getConvMedioDifusionDto() {
        return convMedioDifusionDto;
    }

    public void setConvMedioDifusionDto(ConvocMedioDifusionDto convMedioDifusionDto) {
        this.convMedioDifusionDto = convMedioDifusionDto;
    }

    public MedioDifusionDto getMedioDifusionDto() {
        return medioDifusionDto;
    }

    public void setMedioDifusionDto(MedioDifusionDto medioDifusionDto) {
        this.medioDifusionDto = medioDifusionDto;
    }

    public MiembroComiteDto getMiembroComiteDto() {
        return miembroComiteDto;
    }

    public void setMiembroComiteDto(MiembroComiteDto miembroComiteDto) {
        this.miembroComiteDto = miembroComiteDto;
    }

    public List<ResponsableDto> getListaResponsablesPorReq() {
        return listaResponsablesPorReq;
    }

    public void setListaResponsablesPorReq(List<ResponsableDto> listaResponsablesPorReq) {
        this.listaResponsablesPorReq = listaResponsablesPorReq;
    }

    public Boolean getAccesoBtnPublicar() {
        return accesoBtnPublicar;
    }

    public void setAccesoBtnPublicar(Boolean accesoBtnPublicar) {
        this.accesoBtnPublicar = accesoBtnPublicar;
    }

    public Boolean getAccesoBtnAnular() {
        return accesoBtnAnular;
    }

    public void setAccesoBtnAnular(Boolean accesoBtnAnular) {
        this.accesoBtnAnular = accesoBtnAnular;
    }

    public Boolean getAccesoBtnCerrar() {
        return accesoBtnCerrar;
    }

    public void setAccesoBtnCerrar(Boolean accesoBtnCerrar) {
        this.accesoBtnCerrar = accesoBtnCerrar;
    }

    public Boolean getAccesoBtnGuardar() {
        return accesoBtnGuardar;
    }

    public void setAccesoBtnGuardar(Boolean accesoBtnGuardar) {
        this.accesoBtnGuardar = accesoBtnGuardar;
    }

    public Boolean getAccesoBtnTerminar() {
        return accesoBtnTerminar;
    }

    public void setAccesoBtnTerminar(Boolean accesoBtnTerminar) {
        this.accesoBtnTerminar = accesoBtnTerminar;
    }

    public List<PostulanteDto> getListaPostulantesDto() {
        return listaPostulantesDto;
    }

    public void setListaPostulantesDto(List<PostulanteDto> listaPostulantesDto) {
        this.listaPostulantesDto = listaPostulantesDto;
    }

    public PostulanteDto getPostulanteDto() {
        return postulanteDto;
    }

    public void setPostulanteDto(PostulanteDto postulanteDto) {
        this.postulanteDto = postulanteDto;
    }

    public PersonaDto[] getSelectedPostulantes() {
        return selectedPostulantes;
    }

    public void setSelectedPostulantes(PersonaDto[] selectedPostulantes) {
        this.selectedPostulantes = selectedPostulantes;
    }

    public List<PostulanteDto> getListaPostulantesPorConvDto() {
        return listaPostulantesPorConvDto;
    }

    public void setListaPostulantesPorConvDto(List<PostulanteDto> listaPostulantesPorConvDto) {
        this.listaPostulantesPorConvDto = listaPostulantesPorConvDto;
    }

    public Boolean getAccesoBtnVerPost() {
        return accesoBtnVerPost;
    }

    public void setAccesoBtnVerPost(Boolean accesoBtnVerPost) {
        this.accesoBtnVerPost = accesoBtnVerPost;
    }

    public Date getFechaActual() {
        return UtilCore.Fecha.obtenerFechaActualDate();
    }

    public void setFechaActual(Date fechaActual) {
        this.fechaActual = fechaActual;
    }

    public List<ParametroDto> getListaTiposMiemComite() {
        return this.recursosManager.obtenerParametrosActivosPorCatalogoSistema(ConstantesSele.CatalogoParametro.MIEMBRO_COMITE_TIPO);
    }

    public void setListaTiposMiemComite(List<ParametroDto> listaTiposMiemComite) {
        this.listaTiposMiemComite = listaTiposMiemComite;
    }

    public MiembroComiteDto getMiembroComiteSelectDto() {
        return miembroComiteSelectDto;
    }

    public void setMiembroComiteSelectDto(MiembroComiteDto miembroComiteSelectDto) {
        this.miembroComiteSelectDto = miembroComiteSelectDto;
    }

    public List<RequerimientoDto> getListaRequerimientosPorConvocatoria() {
        return listaRequerimientosPorConvocatoria;
    }

    public void setListaRequerimientosPorConvocatoria(List<RequerimientoDto> listaRequerimientosPorConvocatoria) {
        this.listaRequerimientosPorConvocatoria = listaRequerimientosPorConvocatoria;
    }

    public ConvocatoriaEvaluacionDto getConvEvaluacionDto() {
        return convEvaluacionDto;
    }

    public void setConvEvaluacionDto(ConvocatoriaEvaluacionDto convEvaluacionDto) {
        this.convEvaluacionDto = convEvaluacionDto;
    }
}
